In recent years, data distribution service utilizing a communication function of a portable information terminal typified by a mobile phone, a PHS (Personal Handyphone System), and a PDA (Personal Digital Assistance) is widely available.
As a typical example, there is a distribution service of content such as an image and a melody signaling an incoming mail. It is also possible to download a program, not just data, for executing it as an application on the portable information terminal. That is, by downloading a program, it is possible to use newly added various functions, not just functions (applications) originally installed in the portable information terminal.
By the above-described program distribution service, a PIM (Personal Information Manager) application such as an electric telephone directory and an electric schedule book, and a game application, for example, are supplied. A user can freely select an application having a desired function, an easy-to-use user interface, or a favorite screen structure, and download the program, thereby using the selected application.
Java (™) is promising software architecture to realize a program distribution mechanism. Java (™), which includes a virtual machine mechanism, is able to operate a program independent of hardware and an OS of a machine, thereby being considered effective architecture, not just in a computing field such as a workstation and a personal computer (hereinafter, referred to as a PC for short), but for a household electrical appliance.
Also, as for the portable information terminal, there have already been various models in which the Java (™) virtual machine is installed, and the program distribution service has started. In future, further popularization of the virtual machine mechanism-based program distribution service is to be expected.
However, what becomes a problem when executing the downloaded application on the portable information terminal using the virtual machine mechanism is a length of start-up time.
Here, the start-up time means a time elapsed from when the user or other application (e.g., a browser, a mailer, or a telephone) installed in the portable information terminal gives an instruction to the virtual machine in the portable information terminal to start interpretation execution of a specific application to when an initial screen of the application, which is instructed to be started, is output to a display screen of the portable information terminal. That is, the start-up time is a latency time before the application is enabled, and therefore an unnecessary time for the user because he/she does not use the application during all that time, whereby the longer the start-up time becomes, the less an application execution efficiency becomes.
For example, a start-up process of a typical Java (™) virtual machine is composed of the following three main processes. Hereinafter, Java (™) will be used for descriptions, but the first thing to be described is that other virtual machine can be used instead.    (1) initialization process    (2) class verification process    (3) class loading process
Details of each process are described in a reference (Tim Lindholm and Frank Yellin: “The Java (™) Virtual Machine Specification”, Addison-Wesley, 1997). Hereinafter, only an outline of the process required for the following descriptions will be described.
In Java (™), a program is composed of one or more files called class files. When the program is downloaded, the class files are supplied, in general, packaged in one file, which is decompressed; after downloading, as one or more class files, which are stored as files in the portable information terminal.
(1) The initialization process is an initialization operation required for enabling execution of the Java (™) virtual machine. Specifically, a process for reserving a memory area (e.g., a Java heap area) used by the virtual machine, an initialization of a garbage collection process, an initialization of a class loader, and an initialization of thread management, for example, are performed.
(2) The class verification process is a process performed for verifying security of a program to be executed. Specifically, a format of a class file is checked, and a byte code, for example, included in the class file is checked whether to be compliant with Java (™) specifications.
(3) The class loading process is a process for decompressing a class file on the memory area used by the virtual machine as a storage format (hereinafter, referred to as a runtime execution format) executable by the Java (™) virtual machine. The object class file includes a class file having a main method, which is the first execution method of the program to be executed, and all class files which can be traced based on the above-described class file.
Due to the above-described processes, the start-up time of the application utilizing the virtual machine mechanism is longer than that required for starting an application (native application) written in a machine language of the portable information terminal.
As for the start-up time of (2) the class verification process and (3) the class loading process, in general, the greater an application (program) size becomes, the longer a time required by the process becomes, whereby application execution efficiency is reduced. Especially, user-friendliness of an application such as a PIM application, which requires frequent start-ups, can be substantially reduced.
On the other hand, a technique for enhancing application execution efficiency by performing some type of process for a Java (™) processing class file format is disclosed in Japanese Patent Laid-Open Publication No. 2000-29706 gazette “method and device for preprocessing and packaging of class file”, and Japanese Patent Laid-Open Publication No. H11-327906 gazette “static connection of call dynamically dispatched in the presence of dynamic linking and dynamic loading”.
However, the techniques disclosed in the above-described Japanese Patent Laid-Open Publication No. 2000-29706 gazette and Japanese Patent Laid-Open Publication No. H11-327906 gazette are both designed for speeding up of interpretation execution speed of an application and efficient use of a memory, and are not designed for realizing reduction of a start-up time, which often becomes problems in a case where a processing system such as Java (™) is applied to a household information electrical appliance such as a mobile phone whose price and size, etc., are severely constrained regarding hardware resources.
In order to solve the above-described problems, the present invention is designed to reduce a program start-up time by dividing (3) the class loading process included in the start-up process into “a class loading process necessary for a start-up of an application for the first time” and “a class loading process necessary for a start-up of the application for the second and subsequent times”, and storing the processing results of the “first-time class loading process” as a record format (hereinafter, a temporary runtime execution format) different from a class file format, whereby only the “second-and-subsequent-time class loading process” is required at a start-up of the program.